package com.zwh.se.collection.concurrent;

import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author yexi
 * 并发类容器：是对处于java.util.concurrent包下的容器的一个统称,于JDK1.5时增加。
 * 相对于同步类容器比如Hashtable、Vector之类的，做了很多的优化，在保证线程安全的前提下，提高了性能和吞吐量。
 *
 * ConcurrentHashMap替代了HashTable
 * ConcurrentSkipListMap替代了TreeMap
 */
@SuppressWarnings("all")
public class ConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        //选择一个容器
        ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();//并发HashMap容器
        Hashtable<String, Integer> hashtable = new Hashtable<>();//全部使用同步方法的Hashtable
        HashMap<String, Integer> hashMap = new HashMap<>();//线程不安全情况下的HashMap
        Map<String, Integer> synchronizedMap = Collections.synchronizedMap(hashMap);//线程安全情况下的HashMap

        //创建10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                long startTime = System.currentTimeMillis();
                for (int j = 0; j < 1000000; j++) {
                    concurrentHashMap.put("test" + j, j);
                }
                long endTime = System.currentTimeMillis();
                System.out.println("concurrentHashMap一共需要的时间：" + (endTime - startTime));
            }).start();
        }

        Thread.sleep(4000);

        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                long startTime = System.currentTimeMillis();
                for (int j = 0; j < 1000000; j++) {
                    hashtable.put("test" + j, j);
                }
                long endTime = System.currentTimeMillis();
                System.out.println("hashtable一共需要的时间：" + (endTime - startTime));
            }).start();
        }

        Thread.sleep(4000);

        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                long startTime = System.currentTimeMillis();
                for (int j = 0; j < 1000000; j++) {
                    hashMap.put("test" + j, j);
                }
                long endTime = System.currentTimeMillis();
                System.out.println("hashMap一共需要的时间：" + (endTime - startTime));
            }).start();
        }

        Thread.sleep(4000);

        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                long startTime = System.currentTimeMillis();
                for (int j = 0; j < 1000000; j++) {
                    synchronizedMap.put("test" + j, j);
                }
                long endTime = System.currentTimeMillis();
                System.out.println("线程安全的hashMap一共需要的时间：" + (endTime - startTime));
            }).start();
        }
    }

    //总结：
    // ConcurrentHashMap：性能高，线程安全
    // Hashtable: 线程安全，性能低
    // HashMap:线程不安全，性能高
    // 线程安全的HashMap：线程安全，性能低
}

